Heterogeneous Agent Systems: A Review

been around for more than a decade. Since its beginning, the definition of agent, like the definition of intelligence, has been quite controversial and often provoked hot discussions. Questions such as the following normally come up in such arguments: What is an agent? Should a piece of software be categorized as an agent by looking at its behavioral characteristics or by the methodology using which it was produced? Is a printer daemon an agent? If a piece of software is not an agent, is there a way to make it an agent? Many attempts have been made to define the notion of agent or agency, ranging from quite generic definitions to restrictive definitions. This book adopts a generic definition of an agent: a piece of code that does a small and well-defined job by offering services. Some of its characteristics are declarative specification, autonomous behavior, and interactiveness. This book primarily concentrates on abstracting the data sources and related software to make them agents, hence this less restrictive definition. Although this book might not put an end to the debates mentioned earlier, it tries to answer the most practical question of how to convert a normal program into an agent. Until now, most of the books in this field have discussed the issues in an informal manner or only theoretically without talking about concrete implementations, leaving the reader wondering, “It is all fine, but how do I implement an agent?!” This book fills the gap to some extent. It extensively talks about the implementation of agents, using the IMPACT agent development environment. Also, most of the books in this field are a collection of articles written by different authors, often lacking coherence and consistency. Although written by seven authors, the treatment in this book is quite coherent and consistent. The book starts off with the following questions: What is an agent? If a piece of software is not an agent, how do you make it an agent? As a response, the authors give 10 desiderata for agents and agent platforms. These desiderata roughly cover issues such as the accessing of heterogeneous data sources, a declarative framework for specifying actions, types of reasoning, security, efficiency, reliability, and validation. Of these issues, validation of an infrastructure by deploying a set of applications seems out of place. The main contributions of this book are an approach to making a normal program an agent and providing a practicustomer. The flight terrain application is primarily used to maintain the path of a flight, taking into consideration the current position and three-dimensional terrain information provided by satellites and terrain databases, respectively. The supply-chain management application takes care of the inventory levels and the ordering logistics for production companies. All the applications, especially the last two, have characteristics that make them suitable for using agents. First, they consist of multiple, largely independent, and well-defined tasks to be done. Second, there are independent data sources, and these sources are independently updated. Third, the actions executed can vary depending on the circumstances. Fourth, the entities in the applications need to reason with uncertain data and the beliefs they hold about other entities in the domain. This book can roughly be divided into three parts: (1) basic concepts, (2) implementation, and (3) advanced concepts. The first part discusses basic concepts such as the IMPACT architecture, service description language, the converting of legacy data and software into agents, and the development of agents. In chapter 2, the IMPACT architecture is discussed. One distinguishing feature of IMPACT is that it supports fuzzy matchmaking using concept hierarchies. The service description language is discussed in chapter 3. Chapter 4 contains the core concepts of the book—converting, by use of code calls, legacy data and software application program interfaces (APIs) into services. After converting the APIs and defining the constraints, the agent code looks similar to a PROLOG program. Chapter 6 discusses the components of agent programs—action base and action constraints—which is followed by a discussion of the syntax and semantics of the agent programs. Part 1 is not very formal and is highly readable. The second part discusses implementation issues. The IMPACT server implementation and protocol details are given in chapter 5. Chapter 12 discusses the implementations for issues such as the compiling of the agent programs and safety checks.